module klang.klang.类型.klang类型_;
import 全局;
import klang.编译.类型.枚举值.枚举值_: SK, TK, 比较结果_, 通配符目录标志_;
import klang.编译.类型.类型_: 编译选项基类_, 符号_, 类型_, 签名_, 解析的模块名称_, 符号表_, 打印选项_, 三元结果_;
import klang.编译.triple.Triple: Triple;
import klang.编译.诊断.诊断_: 诊断_;
import klang.编译.语法节点.节点_: 节点_;
import klang.编译.核心.核心_: 词典_, 整数_, 创建数组;
import klang.klang.语法节点.Klang节点_: 运算符签名_, 索引签名_, Klang节点_, 外部修饰符声明_, 标识符_ = Klang标识符_;
alias 类型比较_ = Ternary delegate(Klang类型_, Klang类型_, bool);
alias 联合类型_ = Klang类型_;
alias 可选类型_ = Klang类型_;
alias 字面量类类型_ = Klang类型_;
alias 数组类型_ = Klang类型_;
alias 动态数组_ = Klang类型_;
alias 变长参数类型_ = Klang类型_;
alias 类型列表类型_ = Klang类型_;
alias 指针类型_ = Klang类型_;
alias 词典类型_ = Klang类型_;
alias 元组类型_ = Klang类型_;
alias 只读类型_ = Klang类型_;
alias 恒定类型_ = Klang类型_;
alias 共享类型_ = Klang类型_;
alias 对象接口_ = Klang类型_;
alias 结构接口_ = Klang类型_;
alias 实例化类型_ = Klang类型_;
alias 类型形参_ = Klang类型_;
alias 类类型_ = Klang类型_;
alias 结构类型_ = Klang类型_;
alias 接口类型_ = Klang类型_;
alias 事件类型_ = Klang类型_;
alias 类型类型_ = Klang类型_;
alias 匿名类型_ = Klang类型_;
alias 程序类型_ = Klang类型_;
alias 排除集类型_ = Klang类型_;
alias 类型映射_ = 类型_ delegate(类型_);
enum 节点标志_ : ulong {
    无 = 0uL,
    节点有错误 = 1uL,
    节点或子节点有错误 = 2uL,
    已聚合了子节点错误 = 4uL,
    有JsDoc = 8uL,
    节点组中最后一个 = 16uL,
    不输出文件 = 32uL,
    Synthesized = 64uL,
    是容器块 = 256uL,
    Let = 512uL,
    Const = 1024uL,
    文本内容标识符 = 2048uL,
    OptionalChain = 4096uL,
    HasImplicitReturn = 8192uL,
    HasExplicitReturn = 16384uL,
    是基类调用_ = 32768uL,
    具有断言作用_ = 65536uL,
    // These flags will be set when the parser encounters a dynamic import expression or 'import.meta' to avoid
    // walking the tree if the flags are not set. However, these flags are just a approximation
    // (hence why it's named "PossiblyContainsDynamicImport") because once set, the flags never get cleared.
    // During editing, if a dynamic import is removed, 增量编译 parsing will *NOT* clear this flag.
    // This means that the tree will always be traversed during module resolution, or when looking for external module indicators.
    // However, the removal operation should not occur often and in the case of the
    // removal, it is likely that users will add the import anyway.
    // The advantage of this approach is its simplicity. For the case of batch compilation,
    // we guarantee that users won't have to pay the price of walking the tree if a dynamic import isn't used.
    /* @internal */
    Ambient = 131072uL,
    JsonFile = 262144uL,
    dlangAmbient = 524288uL,
    dlangLib = 1048576uL,
    dlang块_ = 2097152uL,
    导入了dlang块_ = 4194304uL,
    外部文件_ = 8388608uL,
    全局文件_ = 16777216uL,
    类型查询上下文_ = 33554432uL,
    在版本验证上下文_ = 67108864uL,
    在测试单元上下文_ = 134217728uL,
    转换词典上下文_ = 268435456uL,
    DF = 536870912uL,
    F = 1073741824uL,
    FI = 2147483648uL,
    I = 4294967296uL,
    G = 8589934592uL,
    M = 17179869184uL,
    S = 34359738368uL,
    X = 68719476736uL,
    U = 137438953472uL,
    UL = 274877906944uL,
    L = 549755813888uL,
    C = 1099511627776uL,
    W = 2199023255552uL,
    D = 4398046511104uL,
    私有的 = 8796093022208uL,
    是空的 = 17592186044416uL,
    有转义 = 35184372088832uL,
    有扩展转义 = 70368744177664uL,
    是初始函数 = 140737488355328uL,
    是启动函数 = 281474976710656uL,
    不检查初始化 = 562949953421312uL,
    括号表达式 = 1125899906842624uL,
    忽略括号输出 = 2251799813685248uL,
    是测试启动函数 = 4503599627370496uL,
    是静态的_ = 9007199254740992uL,
    是泛型声明_ = 18014398509481984uL,
    全局变量_ = 36028797018963968uL,
    TypeCached = 72057594037927936uL,
    Deprecated = 144115188075855872uL,
    包含词典键值表达式_ = 288230376151711744uL,
    包含展开表达式_ = 576460752303423488uL,
    第一次赋值标志_ = 1152921504606846976uL,
    第二次赋值标志_ = 2305843009213693952uL,
    多次赋值错误_ = 4611686018427387904uL,
    完成检查_ = 9223372036854775808uL,
    BlockScoped = 1536uL,
    ReachabilityCheckFlags = 24576uL,
    ReachabilityAndEmitFlags = 24576uL,
    // Parsing context flags
    ContextFlags = 1703936uL
}
enum KSK : long {
    未知__ = 0L,
    文件结尾 = 1L,
    单行注释 = 2L,
    多行注释 = 3L,
    新行 = 4L,
    空白 = 5L,
    指令注释 = 6L,
    冲突标记 = 7L,
    数字字面量 = 8L,
    文本字面量 = 9L,
    左大括号 = 10L,
    右大括号 = 11L,
    左括号 = 12L,
    右括号 = 13L,
    左方括号 = 14L,
    右方括号 = 15L,
    双引号 = 16L,
    单引号 = 17L,
    点号 = 18L,
    分号 = 19L,
    逗号 = 20L,
    左尖括号 = 21L,
    右尖括号 = 22L,
    加号 = 23L,
    减号 = 24L,
    星号 = 25L,
    反斜杠 = 26L,
    除号 = 27L,
    百分号 = 28L,
    且号 = 29L,
    或号 = 30L,
    异或号 = 31L,
    叹号 = 32L,
    波折号 = 33L,
    美元 = 34L,
    问号 = 35L,
    冒号 = 36L,
    艾特 = 37L,
    井号 = 38L,
    反引号 = 39L,
    等号 = 40L,
    下划线 = 41L,
    连续运算符 = 42L,
    保留不使用标识符 = 43L,
    保留不使用目标 = 44L,
    保留不使用类型符号签名系统 = 45L,
    保留不使用源文件 = 46L,
    /** := */
    冒等号 = 47L,
    /** => */
    等右尖号 = 48L,
    /** ... */
    三点号 = 49L,
    /** .. */
    二点号 = 50L,
    /** .[ */
    点左方括号 = 51L,
    /** .< */
    点左尖括号 = 52L,
    /** .( */
    点左括号 = 53L,
    /** ?. */
    问点号 = 54L,
    /** <= */
    左尖等号 = 55L,
    /** \>= */
    右尖等号 = 56L,
    /** == */
    等等号 = 57L,
    /** != */
    叹等号 = 58L,
    /** && */
    且且号 = 59L,
    /** || */
    或或号 = 60L,
    /** ++ */
    加加号 = 61L,
    /** -- */
    减减号 = 62L,
    /** << */
    左左尖号 = 63L,
    /** \>\> */
    右右尖号 = 64L,
    /** \>\>\> */
    右右右尖号 = 65L,
    /** += */
    加等号 = 66L,
    /** -= */
    减等号 = 67L,
    /** *= */
    星等号 = 68L,
    /** /= */
    除等号 = 69L,
    /** %= */
    余等号 = 70L,
    /** ~= */
    连接等号 = 71L,
    /** <<= */
    左左尖等号 = 72L,
    /** \>\>= */
    右右尖等号 = 73L,
    /** \>\>\>= */
    右右右尖等号 = 74L,
    /** &= */
    且等号 = 75L,
    /** |= */
    或等号 = 76L,
    /** ^= */
    异或等号 = 77L,
    // KSK 标识符
    标识符 = 78L,
    /** 跳出 */
    跳出_ = 79L,
    常量_ = 80L,
    恒定_ = 81L,
    只读_ = 82L,
    共享_ = 83L,
    静态_ = 84L,
    引用_ = 85L,
    局部_ = 86L,
    固定_ = 87L,
    声明_ = 88L,
    公开_ = 89L,
    私有_ = 90L,
    保护_ = 91L,
    重载_ = 92L,
    外部_ = 93L,
    导出_ = 94L,
    返回_ = 95L,
    /** 异步 */
    异步_ = 96L,
    /** 等待 */
    等待_ = 97L,
    /** 继续 */
    继续_ = 98L,
    /** 调试 */
    调试_ = 99L,
    /** 默认 */
    默认_ = 100L,
    /** 删除 */
    删除_ = 101L,
    /** 否则 */
    否则_ = 102L,
    /** 枚举 */
    枚举_ = 103L,
    /** 循环 */
    循环_ = 104L,
    /** 函数 */
    函数_ = 105L,
    /** 如果 */
    如果_ = 106L,
    /** 导入 */
    导入_ = 107L,
    /** 新建 */
    新建_ = 108L,
    /** 若是 */
    若是_ = 109L,
    /** 抛出 */
    抛出_ = 110L,
    /** 尝试 */
    尝试_ = 111L,
    /** 捕获 */
    捕获_ = 112L,
    /** 最后 */
    最后_ = 113L,
    同步_ = 114L,
    /** 对象 */
    对象_ = 115L,
    /** 结构 */
    结构_ = 116L,
    /** 别名 */
    别名_ = 117L,
    /** 接口 */
    接口_ = 118L,
    /** 延迟 */
    延迟_ = 119L,
    /** 另如 */
    另如_ = 120L,
    /** 程序 */
    程序_ = 121L,
    指令_ = 122L,
    汇编_ = 123L,
    测试_ = 124L,
    /** 假如 */
    假如_ = 125L,
    /** 本体 */
    本体_ = 126L,
    基类_ = 127L,
    原型_ = 128L,
    /** 未知关键字 */
    未知_ = 129L,
    零值_ = 130L,
    空址_ = 131L,
    /** 整数 */
    整数_ = 132L,
    /** 正整数 */
    正整数_ = 133L,
    /** 小数 */
    小数_ = 134L,
    虚数_ = 135L,
    复数_ = 136L,
    /** 大小 */
    正量_ = 137L,
    /** 指针 */
    指针_ = 138L,
    /** 空值 */
    空值_ = 139L,
    /** 假 */
    假_ = 140L,
    /** 真 */
    真_ = 141L,
    /** 不及 */
    不及_ = 142L,
    /** 无值 */
    无值_ = 143L,
    /** 通用 */
    通用_ = 144L,
    /** 变量 */
    变量_ = 145L,
    /** 真假 */
    真假_ = 146L,
    /** 文字 */
    文本_ = 147L,
    /** 文字 */
    文本8_ = 148L,
    /** 文字 */
    文本16_ = 149L,
    /** 文字 */
    文本32_ = 150L,
    /** 类型 */
    整数8_ = 151L,
    整数16_ = 152L,
    整数32_ = 153L,
    整数64_ = 154L,
    正整数8_ = 155L,
    正整数16_ = 156L,
    正整数32_ = 157L,
    正整数64_ = 158L,
    小数32_ = 159L,
    小数64_ = 160L,
    虚数32_ = 161L,
    虚数64_ = 162L,
    复数64_ = 163L,
    复数128_ = 164L,
    字符_ = 165L,
    字符8_ = 166L,
    字符16_ = 167L,
    字符32_ = 168L,
    字节_ = 169L,
    全局_ = 170L,
    /** 启动 */
    启动_ = 171L,
    /** 初始 */
    初始_ = 172L,
    版本_ = 173L,
    属于_ = 174L,
    断言_ = 175L,
    构建_ = 176L,
    释放_ = 177L,
    纯净_ = 178L,
    安全_ = 179L,
    信任_ = 180L,
    系统_ = 181L,
    无回收_ = 182L,
    不抛出_ = 183L,
    C_ = 184L,
    C加加_ = 185L,
    D_ = 186L,
    Windows_ = 187L,
    System_ = 188L,
    Objective_C_ = 189L,
    返回局部引用_ = 190L,
    返回引用_ = 191L,
    局部引用_ = 192L,
    返回局部_ = 193L,
    事件_ = 194L,
    类型_ = 195L,
    // 节点
    限定名 = 196L,
    类型形参 = 197L,
    // 类型
    类型引用 = 198L,
    静态二元表达式类型节点 = 199L,
    函数类型 = 200L,
    区间类型节点 = 201L,
    数组类型 = 202L,
    元组类型节点 = 203L,
    类型列表 = 204L,
    联合类型 = 205L,
    括号类型 = 206L,
    词典类型 = 207L,
    动态数组类型 = 208L,
    指针类型 = 209L,
    变长参数 = 210L,
    类型限定类型 = 211L,
    字面量类型 = 212L,
    源文件 = 213L,
    导入成员 = 214L,
    导入从成员 = 215L,
    导入声明 = 216L,
    导入从声明 = 217L,
    导入版本成员 = 218L,
    导入成员块 = 219L,
    导入从成员块 = 220L,
    导入从版本成员 = 221L,
    版本表达式语句 = 222L,
    版本语句 = 223L,
    测试单元语句 = 224L,
    程序声明 = 225L,
    外部修饰符声明 = 226L,
    标识符修饰符 = 227L,
    // 声明
    形参声明 = 228L,
    变量声明列表 = 229L,
    变量声明 = 230L,
    索引签名 = 231L,
    运算符签名 = 232L,
    运算符签名元素 = 233L,
    函数声明 = 234L,
    方法声明 = 235L,
    枚举成员 = 236L,
    属性声明 = 237L,
    构建声明 = 238L,
    释放声明 = 239L,
    枚举声明 = 240L,
    接口声明 = 241L,
    对象声明 = 242L,
    结构声明 = 243L,
    类型声明 = 244L,
    别名声明 = 245L,
    失踪声明 = 246L,
    同步语句 = 247L,
    块 = 248L,
    合成注释 = 249L,
    空语句 = 250L,
    变量语句 = 251L,
    断言语句 = 252L,
    如果语句 = 253L,
    指令语句 = 254L,
    循环属于 = 255L,
    循环语句 = 256L,
    当循环语句 = 257L,
    跳出语句 = 258L,
    继续语句 = 259L,
    延迟语句 = 260L,
    删除语句 = 261L,
    返回语句 = 262L,
    假如语句 = 263L,
    抛出语句 = 264L,
    尝试语句 = 265L,
    调试语句 = 266L,
    标签语句 = 267L,
    表达式语句 = 268L,
    /** 表达式 */
    字符字面量 = 269L,
    小数字面量 = 270L,
    正则表达式字面量 = 271L,
    无替换模板字面量 = 272L,
    模板头 = 273L,
    模板中 = 274L,
    模板尾 = 275L,
    前缀一元表达式 = 276L,
    后缀一元表达式 = 277L,
    二元表达式 = 278L,
    属性访问表达式 = 279L,
    元素访问表达式 = 280L,
    新建表达式 = 281L,
    调用表达式 = 282L,
    数组字面量表达式 = 283L,
    表达式列表表达式 = 284L,
    动态类字面量表达式 = 285L,
    词典键值表达式 = 286L,
    结构字面量表达式 = 287L,
    接口字面量表达式 = 288L,
    函数表达式 = 289L,
    模板表达式 = 290L,
    非空表达式 = 291L,
    截取表达式 = 292L,
    展开表达式 = 293L,
    属性赋值 = 294L,
    简洁属性赋值 = 295L,
    条件表达式 = 296L,
    类型查询表达式 = 297L,
    类型断言表达式 = 298L,
    类型转换表达式 = 299L,
    箭头函数 = 300L,
    表达式包含类型实参 = 301L,
    符号引用表达式 = 302L,
    部分输出表达式 = 303L,
    省略表达式 = 304L,
    若是块 = 305L,
    继承子句 = 306L,
    若是子句 = 307L,
    默认子句 = 308L,
    捕获子句 = 309L,
    数量_ = 310L,
    第一个关键字 = 79L,
    最后一个关键字 = 195L,
    第一个上下文关键字_ = 170L,
    最后一个上下文关键字_ = 195L,
    第一个字面量 = 8L,
    最后一个字面量 = 9L,
    第一个字面量klang = 269L,
    最后一个字面量klang = 275L,
    第一个模板 = 272L,
    最后一个模板 = 275L,
    第一个复合赋值 = 66L,
    最后一个复合赋值 = 77L,
    第一个语句 = 251L,
    最后一个语句 = 268L,
    第一个节点 = 196L,
    FirstTypeNode = 198L,
    LastTypeNode = 212L
}
enum 版本容器块种类_ : int {
    无_ = 0,
    是版本容器块_ = 1,
    是版本另如容器块_ = 2,
    是版本否则容器块_ = 4,
    是声明块_ = 8,
    是局部声明块_ = 16,
    是测试单元_ = 32
}
enum AssertFlags : int {
    无_ = 0,
    联合断言_ = 2,
    类型参数断言_ = 4,
    通用类型断言_ = 8,
    接口类型断言_ = 16,
    非表达式断言_ = 64,
    字面量断言_ = 128,
    联合字面量断言_ = 256,
    静态断言_ = 1024,
    可选类型断言_ = 2048,
    可选联合断言_ = 4096,
    空值断言_ = 8192,
    类型声明原型断言_ = 16384,
    指针基础类型断言_ = 32768,
    自动变量断言_ = 65536
}
enum Klang输出种类_ : int {
    无_ = 0,
    IR = 1
}
enum 模块导入位置种类_ : int {
    无_ = 0,
    外部支持库_ = 1,
    从全局位置导入的外部模块_ = 2,
    全局支持库_ = 3
}
enum 扩展名_ : dstring {
    K = ".k2"d,
    DK = ".d.k2"d
}
enum 配置文件名_ : dstring {
    Klang = "k2config.json"d,
    KlangMod = "k2lang.mod.json"d
}
enum Ternary : int {
    False = 0,
    Maybe = 1,
    True = -1
}
enum 推理标志_ : int {
    None = 0,
    NoDefault = 1,
    AnyDefault = 2,
    SkippedGenericFunction = 4
}
enum 推理优先级_ : int {
    无_ = 0,
    NakedTypeVariable = 1,
    SpeculativeTuple = 2,
    SubstituteSource = 4,
    HomomorphicMappedType = 8,
    PartialHomomorphicMappedType = 16,
    MappedTypeConstraint = 32,
    ContravariantConditional = 64,
    ReturnType = 128,
    LiteralKeyof = 256,
    NoConstraints = 512,
    AlwaysStrict = 1024,
    MaxValue = 2048,
    PriorityImpliesCombination = 416,
    Circularity = -1
}
enum ContextFlags : int {
    None = 0,
    Signature = 1,
    NoConstraints = 2,
    Completions = 4,
    SkipBindingPatterns = 8
}
enum 签名种类_ : int {
    Call = 0,
    Construct = 1
}
enum UnionReduction : int {
    None = 0,
    Literal = 1,
    Subtype = 2
}
enum 符号标志_ : long {
    无_ = 0L,
    程序集_ = 1L,
    对象_ = 2L,
    接口_ = 4L,
    结构_ = 8L,
    类型别名_ = 16L,
    类型声明_ = 32L,
    枚举声明_ = 64L,
    属性_ = 128L,
    别名_ = 256L,
    程序集导入_ = 512L,
    形参声明_ = 1024L,
    类型形参_ = 2048L,
    局部变量_ = 4096L,
    全局变量_ = 8192L,
    变量_ = 12288L,
    索引签名_ = 16384L,
    运算符签名_ = 32768L,
    构建_ = 65536L,
    释放_ = 131072L,
    方法_ = 262144L,
    枚举成员_ = 524288L,
    函数_ = 1048576L,
    签名_ = 2097152L,
    类型字面量_ = 4194304L,
    结构字面量_ = 8388608L,
    私有_ = 16777216L,
    不使用_ = 33554432L,
    保护_ = 67108864L,
    重载_ = 134217728L,
    导出_ = 268435456L,
    外部_ = 536870912L,
    公开_ = 1073741824L,
    只读_ = 2147483648L,
    恒定_ = 4294967296L,
    共享_ = 8589934592L,
    静态_ = 17179869184L,
    引用_ = 34359738368L,
    局部_ = 68719476736L,
    固定_ = 137438953472L,
    返回_ = 274877906944L,
    纯净_ = 549755813888L,
    安全_ = 1099511627776L,
    信任_ = 2199023255552L,
    系统_ = 4398046511104L,
    无回收_ = 8796093022208L,
    不抛出_ = 17592186044416L,
    返回局部引用_ = 377957122048L,
    返回引用_ = 309237645312L,
    局部引用_ = 103079215104L,
    返回局部_ = 343597383680L,
    内部声明_ = 35184372088832L,
    已有默认构建_ = 70368744177664L,
    已有拷贝构建_ = 140737488355328L,
    声明_ = 281474976710656L,
    虚拟符号_ = 562949953421312L,
    符号占位符_ = 1125899906842624L,
    临时_ = 2251799813685248L,
    可选_ = 1152921504606846976L,
    全部_ = 316109609762303L,
    值_ = 281474989293055L,
    类型_ = 4721022L,
    有成员_ = 12583023L,
    程序集排除_ = 316109609762302L,
    索引签名排除_ = 316109609745919L,
    运算符签名排除_ = 316109609729535L,
    构建排除_ = 316109609696767L,
    释放排除_ = 316109609762303L,
    方法排除_ = 316109609500159L,
    别名排除_ = 316109609762303L,
    类型形参排除_ = 316109609762303L,
    形参声明排除_ = 316109609762303L,
    局部变量排除_ = 316109609762303L,
    全局变量排除_ = 316109609762303L,
    属性排除_ = 316109609762303L,
    枚举成员排除_ = 316109609762303L,
    函数排除_ = 316109608713727L,
    签名排除_ = 316109609762303L,
    结构排除_ = 316109609762303L,
    接口排除_ = 316109609762303L,
    对象排除_ = 316109609762303L,
    类型别名排除_ = 316109609762303L,
    类型声明排除_ = 316109609762303L,
    枚举声明排除_ = 316109609762303L
}
enum 类型标志_ : long {
    无_ = 0L,
    未知_ = 1L,
    不及_ = 2L,
    无值_ = 4L,
    任意_ = 8L,
    空值_ = 16L,
    真假_ = 32L,
    整数8_ = 64L,
    整数16_ = 128L,
    整数32_ = 256L,
    整数64_ = 512L,
    正整数8_ = 1024L,
    正整数16_ = 2048L,
    正整数32_ = 4096L,
    正整数64_ = 8192L,
    小数32_ = 16384L,
    小数64_ = 32768L,
    虚数32_ = 65536L,
    虚数64_ = 131072L,
    复数64_ = 262144L,
    复数128_ = 524288L,
    文本8_ = 1048576L,
    文本16_ = 2097152L,
    文本32_ = 4194304L,
    字符8_ = 8388608L,
    字符16_ = 16777216L,
    字符32_ = 33554432L,
    枚举_ = 67108864L,
    文本字面量8_ = 134217728L,
    文本字面量16_ = 268435456L,
    文本字面量32_ = 536870912L,
    字符字面量8_ = 1073741824L,
    字符字面量16_ = 2147483648L,
    字符字面量32_ = 4294967296L,
    整数字面量8_ = 8589934592L,
    整数字面量16_ = 17179869184L,
    整数字面量32_ = 34359738368L,
    整数字面量64_ = 68719476736L,
    正整数字面量8_ = 137438953472L,
    正整数字面量16_ = 274877906944L,
    正整数字面量32_ = 549755813888L,
    正整数字面量64_ = 1099511627776L,
    小数字面量32_ = 2199023255552L,
    小数字面量64_ = 4398046511104L,
    虚数字面量32_ = 8796093022208L,
    虚数字面量64_ = 17592186044416L,
    未定_ = 35184372088832L,
    可选类型_ = 70368744177664L,
    真字面量_ = 140737488355328L,
    假字面量_ = 281474976710656L,
    枚举字面量_ = 562949953421312L,
    排除集类型_ = 1125899906842624L,
    对象字面量_ = 9007199254740992L,
    结构字面量_ = 18014398509481984L,
    接口字面量_ = 36028797018963968L,
    字节_ = 72057594037927936L,
    联合_ = 144115188075855872L,
    区间_ = 288230376151711744L,
    类型形参_ = 576460752303423488L,
    限定类型_ = 1152921504606846976L,
    对象_ = 2305843009213693952L,
    复合_ = 4611686018427387904L,
    全部_ = 9223372036854775807L,
    数字字面量_ = 2190433320960L,
    内置数字类型_ = 16320L,
    数字类_ = 2190433337280L,
    文本字面量_ = 939524096L,
    内置文本类_ = 7340032L,
    文本类_ = 946864128L,
    文本8类的_ = 135266304L,
    文本16类的_ = 270532608L,
    文本32类的_ = 541065216L,
    真假类的_ = 422212465066016L,
    整数32类的_ = 60129542592L,
    整数64类的_ = 68719477248L,
    整数类的_ = 128849019840L,
    正整数32类的_ = 962072681472L,
    正整数64类的_ = 1099511635968L,
    正整数类的_ = 2061584317440L,
    应提升为整数的_ = 72479869878927840L,
    应提升为正整数的_ = 966401203200L,
    小数字面量_ = 32985348833280L,
    小数类_ = 1032192L,
    小数32类的_ = 2199023271936L,
    小数64类的_ = 4398046543872L,
    虚数32类的_ = 8796093087744L,
    虚数64类的_ = 17592186175488L,
    可作为强转源类型_ = 72514989861109728L,
    可作为强转目标类型_ = 72057594097696736L,
    可赋值给复数128的_ = 35175783202752L,
    可赋值给复数64的_ = 12017318845888L,
    可赋值给小数64的_ = 35175782416320L,
    可赋值给小数32的_ = 12017318583744L,
    字符字面量_ = 7516192768L,
    字符类_ = 58720256L,
    字符8类的_ = 1082130432L,
    字符16类的_ = 2164260864L,
    字符32类的_ = 4328521728L,
    值类型_ = 360727773826777056L,
    对象字面量类_ = 63050394783186944L,
    字面量_ = 598134191292416L,
    结构类的_ = 3602879701896396800L,
    类型变量_ = 576460752303423488L,
    Primitive = 72655728363438068L,
    扩展内置类型_ = 73077940761395188L,
    IncludesMask = 2450556331480842267L,
    NotPrimitiveUnion = 2882303761584226319L,
    Nullable = 35184372088848L,
    唯一_ = 1020346656358448L,
    Narrowable = 7639195683420897320L,
    PossiblyFalsy = 351843586670612L
}
enum 复合标志_ : long {
    无_ = 0L,
    数组_ = 1L,
    动态_ = 2L,
    元组_ = 4L,
    词典_ = 8L,
    指针_ = 16L,
    变长_ = 32L,
    列表_ = 64L,
    只读_ = 128L,
    共享_ = 256L,
    恒定_ = 512L,
    引用_ = 1024L,
    输出_ = 2048L,
    局部_ = 4096L,
    返回_ = 8192L,
    类_ = 16384L,
    结构_ = 32768L,
    接口_ = 65536L,
    类型_ = 131072L,
    事件_ = 262144L,
    程序_ = 524288L,
    匿名_ = 1048576L,
    委托_ = 2097152L,
    函数_ = 4194304L,
    泛型引用_ = 8388608L,
    实例化的_ = 16777216L,
    内置类型字面量_ = 33554432L,
    常规字面量_ = 67108864L,
    PrimitiveUnion = 134217728L,
    ContainsIntersections = 268435456L,
    包含类型变量已计算_ = 536870912L,
    包含类型变量_ = 1073741824L,
    结构接口_ = 2147483648L,
    对象接口_ = 4294967296L,
    零值_ = 4294967296L,
    空址_ = 8589934592L,
    空值_ = 17179869184L,
    空类_ = 30064771072L,
    NonInferrableType = 34359738368L,
    是对象类的拷贝_ = 68719476736L,
    是固定的_ = 137438953472L,
    可选类型_ = 274877906944L,
    类型可断言已计算_ = 549755813888L,
    类型可断言_ = 1099511627776L,
    断言通用_ = 2199023255552L,
    断言联合_ = 4398046511104L,
    断言接口_ = 8796093022208L,
    断言类型形参_ = 17592186044416L,
    具有断言否定集_ = 35184372088832L,
    合成类型形参_ = 70368744177664L,
    通用剩余类型_ = 140737488355328L,
    类型形参_ = 281474976710656L,
    虚拟外部类型_ = 562949953421312L,
    虚拟外部函数_ = 1125899906842624L,
    声明成员已经解析_ = 1152921504606846976L,
    RequiresWidening = 100663296L,
    不能作为类型形参约束类型_ = 6543115259L,
    PropagatingFlags = 137539616768L
}
enum 签名标志_ : long {
    无_ = 0L,
    HasRestParameter = 1L,
    HasLiteralTypes = 2L,
    IsOptionalCall = 4L,
    isNewCall = 8L,
    是释放签名 = 16L,
    是虚拟的_ = 32L,
    是全参的_ = 64L,
    是方法签名_ = 128L,
    有类型参数_ = 256L,
    有外部类型参数_ = 512L,
    是覆盖签名_ = 1024L,
    是字面量构建签名_ = 2048L,
    是多返回值的_ = 4096L,
    是只读签名_ = 8192L,
    是恒定签名_ = 16384L,
    是共享签名_ = 32768L,
    是局部签名_ = 65536L,
    是静态签名_ = 131072L,
    是固定的_ = 262144L,
    是关联固定_ = 524288L,
    返回接口字面量_ = 1048576L,
    是私有的_ = 2097152L,
    是拷贝构建_ = 4194304L,
    是默认构建_ = 8388608L,
    有通用类型_ = 16777216L,
    有可选参数_ = 33554432L,
    有通用剩余类型_ = 67108864L,
    是虚表签名_ = 134217728L,
    有合成类型形参_ = 268435456L,
    是内部嵌套签名_ = 536870912L,
    是泛型签名_ = 1073741824L,
    是纯净_ = 2147483648L,
    是安全_ = 4294967296L,
    是信任_ = 8589934592L,
    是系统_ = 17179869184L,
    是无回收_ = 34359738368L,
    是不抛出_ = 68719476736L,
    是内置类型构建_ = 137438953472L,
    PropagatingFlags = 274865323931L
}
enum 索引种类_ : int {
    文本索引_ = 0,
    数字索引_ = 1
}
enum 字面量值种类_ : int {
    无_ = 0,
    文本8_ = 1,
    文本16_ = 2,
    文本32_ = 3,
    字符8_ = 4,
    字符16_ = 5,
    字符32_ = 6,
    整数8_ = 7,
    整数16_ = 8,
    整数32_ = 9,
    整数64_ = 10,
    正整数8_ = 11,
    正整数16_ = 12,
    正整数32_ = 13,
    正整数64_ = 14,
    小数32_ = 15,
    小数64_ = 16,
    虚数32_ = 17,
    虚数64_ = 18,
    真_ = 19,
    假_ = 20
}
enum 方差_ : int {
    Invariant = 0,
    Covariant = 1,
    Contravariant = 2,
    Bivariant = 3,
    Independent = 4,
    VarianceMask = 7,
    Unmeasurable = 8,
    Unreliable = 16,
    AllowsStructuralFallback = 24
}
enum 符号分析结果_ : long {
    无_ = 0L,
    赋值给全局变量_ = 1L,
    引用了外部变量_ = 2L,
    变量持有形参符号_ = 4L
}
enum 内置类型_ : long {
    未知类型 = 0L,
    errorType = 1L,
    通用类型 = 2L,
    无值类型 = 3L,
    无值指针类型 = 4L,
    无值动态数组类型 = 5L,
    空值类型 = 6L,
    零值类型 = 7L,
    空址类型 = 8L,
    不及类型 = 9L,
    unreachableNeverType = 10L,
    silentNeverType = 11L,
    整数8类型 = 12L,
    整数16类型 = 13L,
    整数32类型 = 14L,
    整数64类型 = 15L,
    正整数8类型 = 16L,
    正整数16类型 = 17L,
    正整数32类型 = 18L,
    正整数64类型 = 19L,
    小数32类型 = 20L,
    小数64类型 = 21L,
    虚数32类型 = 22L,
    虚数64类型 = 23L,
    复数64类型 = 24L,
    复数128类型 = 25L,
    字符8类型 = 26L,
    字符16类型 = 27L,
    字符32类型 = 28L,
    文本8类型 = 29L,
    文本16类型 = 30L,
    文本32类型 = 31L,
    字节类型 = 32L,
    假新鲜类型 = 33L,
    真新鲜类型 = 34L,
    真假类型 = 35L,
    无符号正量类型 = 36L,
    文本8类型_0 = 37L,
    文本8类型_1 = 38L,
    文本16类型_0 = 39L,
    文本16类型_1 = 40L,
    文本32类型_0 = 41L,
    文本32类型_1 = 42L,
    字符8类型_0 = 43L,
    字符8类型_1 = 44L,
    字符16类型_0 = 45L,
    字符16类型_1 = 46L,
    字符32类型_0 = 47L,
    字符32类型_1 = 48L,
    整数8类型_0 = 49L,
    整数8类型_1 = 50L,
    整数16类型_0 = 51L,
    整数16类型_1 = 52L,
    整数32类型_0 = 53L,
    整数32类型_1 = 54L,
    整数64类型_0 = 55L,
    整数64类型_1 = 56L,
    正整数8类型_0 = 57L,
    正整数8类型_1 = 58L,
    正整数16类型_0 = 59L,
    正整数16类型_1 = 60L,
    正整数32类型_0 = 61L,
    正整数32类型_1 = 62L,
    正整数64类型_0 = 63L,
    正整数64类型_1 = 64L,
    小数32类型_0 = 65L,
    小数32类型_1 = 66L,
    小数64类型_0 = 67L,
    小数64类型_1 = 68L,
    虚数32类型_0 = 69L,
    虚数32类型_1 = 70L,
    虚数64类型_0 = 71L,
    虚数64类型_1 = 72L,
    虚拟结构类型 = 73L,
    虚拟类类型 = 74L,
    虚拟函数类型 = 75L,
    虚拟指针类型 = 76L,
    全局对象类型 = 77L,
    全局正则类型 = 78L,
    全局错误类型 = 79L,
    anyFunctionType = 80L
}
enum 枚举种类_ : int {
    无_ = 0,
    数字_ = 1,
    字面量_ = 2
}
enum 符号检查标志_ : long {
    无_ = 0L,
    实例化的_ = 1L,
    SyntheticProperty = 2L,
    SyntheticMethod = 4L,
    Readonly = 8L,
    ReadPartial = 16L,
    WritePartial = 32L,
    HasNonUniformType = 64L,
    HasLiteralType = 128L,
    ContainsPublic = 256L,
    ContainsProtected = 512L,
    ContainsPrivate = 1024L,
    ContainsStatic = 2048L,
    Late = 4096L,
    ReverseMapped = 8192L,
    OptionalParameter = 16384L,
    RestParameter = 32768L,
    Synthetic = 6L,
    Discriminant = 192L,
    Partial = 48L
}
enum 节点检查标志_ : long {
    无_ = 0L,
    TypeChecked = 2L,
    LexicalThis = 4L,
    CaptureThis = 8L,
    CaptureNewTarget = 16L,
    SuperInstance = 32L,
    SuperStatic = 64L,
    ContextChecked = 128L,
    AsyncMethodWithSuper = 256L,
    AsyncMethodWithSuperBinding = 512L,
    CaptureArguments = 1024L,
    EnumValuesComputed = 2048L,
    LexicalModuleMergesWithClass = 4096L,
    LoopWithCapturedBlockScopedBinding = 8192L,
    ContainsCapturedBlockScopeBinding = 16384L,
    CapturedBlockScopedBinding = 32768L,
    BlockScopedBindingInLoop = 65536L,
    ClassWithBodyScopedClassBinding = 131072L,
    BodyScopedClassBinding = 262144L,
    NeedsLoopOutParameter = 524288L,
    AssignmentsMarked = 1048576L,
    ClassWithConstructorReference = 2097152L,
    ConstructorReferenceInClass = 4194304L
}
enum 限定符_ : int {
    无_ = 0,
    只读_ = 1,
    恒定_ = 2,
    共享_ = 4
}
enum 内部符号名_ : dstring {
    调用_ = "·调用"d,
    构建_ = "·构建"d,
    新建_ = "·新建"d,
    失踪_ = "·失踪"d,
    类型_ = "·类型"d,
    对象_ = "·对象"d,
    函数_ = "·函数"d,
    解析中_ = "·解析中"d,
    释放_ = "~本体"d,
    本体_ = "·本体"d,
    原型_ = "·原型"d,
    索引_ = "·索引"d,
    运算符_ = "·运算符"d
}
enum 关系比较结果_ : int {
    Succeeded = 1,
    Failed = 2,
    Reported = 4,
    ReportsUnmeasurable = 8,
    ReportsUnreliable = 16,
    ReportsMask = 24
}
// NOTE: If modifying this enum, must modify `TypeFormatFlags` too!
enum NodeBuilderFlags : long {
    None = 0L,
    // Options
    NoTruncation = 1L,
    WriteArrayAsGenericType = 2L,
    GenerateNamesForShadowedTypeParams = 4L,
    UseStructuralFallback = 8L,
    ForbidIndexedAccessSymbolReferences = 16L,
    WriteTypeArgumentsOfSignature = 32L,
    UseFullyQualifiedType = 64L,
    UseOnlyExternalAliasing = 128L,
    SuppressAnyReturnType = 256L,
    WriteTypeParametersInQualifiedName = 512L,
    MultilineObjectLiterals = 1024L,
    WriteClassExpressionAsTypeLiteral = 2048L,
    UseTypeOfFunction = 4096L,
    OmitParameterModifiers = 8192L,
    UseAliasDefinedOutsideCurrentScope = 16384L,
    UseSingleQuotesForStringLiteralType = 268435456L,
    NoTypeReduction = 536870912L,
    NoUndefinedOptionalParameterType = 1073741824L,
    // Error handling
    AllowThisInObjectLiteral = 32768L,
    AllowQualifiedNameInPlaceOfIdentifier = 65536L,
    /** @deprecated AllowQualifedNameInPlaceOfIdentifier. Use AllowQualifiedNameInPlaceOfIdentifier instead. */
    AllowQualifedNameInPlaceOfIdentifier = 65536L,
    AllowAnonymousIdentifier = 131072L,
    AllowEmptyUnionOrIntersection = 262144L,
    AllowEmptyTuple = 524288L,
    AllowUniqueESSymbolType = 1048576L,
    AllowEmptyIndexInfoType = 2097152L,
    // Errors (cont.)
    AllowNodeModulesRelativePaths = 67108864L,
    /* @internal */ DoNotIncludeSymbolChain = 134217728L,
    IgnoreErrors = 70221824L,
    // State
    InObjectTypeLiteral = 4194304L,
    InTypeAlias = 8388608L,
    InInitialEntityName = 16777216L,
    省略元素限定符_ = 8589934592L
}
// Ensure the shared flags between this and `NodeBuilderFlags` stay in alignment
enum TypeFormatFlags : long {
    None = 0L,
    NoTruncation = 1L,
    WriteArrayAsGenericType = 2L,
    // hole because there's a hole in node builder flags
    UseStructuralFallback = 8L,
    // hole because there's a hole in node builder flags
    WriteTypeArgumentsOfSignature = 32L,
    UseFullyQualifiedType = 64L,
    // hole because `UseOnlyExternalAliasing` is here in node builder flags, but functions which take old flags use `SymbolFormatFlags` instead
    SuppressAnyReturnType = 256L,
    // hole because `WriteTypeParametersInQualifiedName` is here in node builder flags, but functions which take old flags use `SymbolFormatFlags` for this instead
    MultilineObjectLiterals = 1024L,
    WriteClassExpressionAsTypeLiteral = 2048L,
    UseTypeOfFunction = 4096L,
    OmitParameterModifiers = 8192L,
    UseAliasDefinedOutsideCurrentScope = 16384L,
    UseSingleQuotesForStringLiteralType = 268435456L,
    NoTypeReduction = 536870912L,
    // Error Handling
    AllowUniqueESSymbolType = 1048576L,
    // TypeFormatFlags exclusive
    AddUndefined = 131072L,
    WriteArrowStyleSignature = 262144L,
    // State
    InArrayType = 524288L,
    InElementType = 2097152L,
    InFirstTypeArgument = 4194304L,
    InTypeAlias = 8388608L,
    NodeBuilderFlagsMask = 814775659L
}
class 编译选项_ : 编译选项基类_ {
    bool 编译;
    bool 初始;
    bool 帮助;
    bool 版本号;
    bool 监控;
    // 编译选项 "x86_64-pc-windows-msvc"
    dstring 系统;
    dstring 系统版本;
    dstring 架构;
    dstring 环境;
    dstring 环境版本;
    dstring 支持;
    dstring 输出类型;
    dstring 平台;
    dstring 输出模式;
    bool 清屏;
    bool 强制;
    bool 详细;
    bool 清除;
    bool 增量;
    bool 启用诊断;
    Triple 目标平台;
    dstring[] 定义;
    bool 彩色;
    dstring 输出;
    dstring 源码;
    dstring 地区;
    dstring 名称;
    dstring 版本;
    dstring 主页;
    dstring[dstring] 依赖;
    dstring 配置文件;
    dstring 全局模块路径;
    dstring 构建信息文件;
    作者_ 作者;
    作者_[] 贡献;
    this() { }
    this(dstring id) {
        super(id);
    }
}
class Klang打印选项_ : 打印选项_ {
    Klang输出种类_ 输出种类;
    bool 输出英文关键字;
    this() { }
    this(Klang输出种类_ 种类) {
        super("klang打印选项"d);
        this.输出种类 = 种类;
        this.输出英文关键字 = false;
    }
}
class klang解析的模块名称_ : 解析的模块名称_ {
    模块导入位置种类_ 是外部支持库导入;
    dstring 包名;
    this() { }
    this(dstring 名称, dstring 路径, dstring[] 文件名组, 模块导入位置种类_ 是外部支持库导入 = ··null!(模块导入位置种类_), dstring 包名 = ··null!(dstring)) {
        super(名称, 路径, 文件名组);
        this.是外部支持库导入 = 是外部支持库导入;
        this.包名 = 包名;
    }
}
class 推理信息_ {
    Klang类型_ typeParameter; // Type parameter for which inferences are being made
    Klang类型_[] candidates; // Candidates in covariant positions (or undefined)
    Klang类型_[] contraCandidates; // Candidates in contravariant positions (or undefined)
    Klang类型_ inferredType; // Cache for resolved inferred type
    推理优先级_ priority; // Priority of current inference set
    bool topLevel; // True if all inferences are to top level occurrences
    bool isFixed; // True if inferences are fixed
    long impliedArity;
    this() { }
    this(Klang类型_ typeParameter, bool topLevel, bool isFixed, Klang类型_[] candidates = ··null!(Klang类型_[]), Klang类型_[] contraCandidates = ··null!(Klang类型_[]), Klang类型_ inferredType = ··null!(Klang类型_), 推理优先级_ priority = ··null!(推理优先级_), long impliedArity = ··null!(long)) {
        this.typeParameter = typeParameter;
        this.topLevel = topLevel;
        this.isFixed = isFixed;
        this.candidates = candidates;
        this.contraCandidates = contraCandidates;
        this.inferredType = inferredType;
        this.priority = priority;
        this.impliedArity = impliedArity;
    }
}
/* @internal */
class 推理上下文_ {
    推理信息_[] inferences; // Inferences made for each type parameter
    Klang签名_ signature; // Generic signature for which inferences are made (if any)
    推理标志_ flags; // Inference flags
    类型比较_ compareTypes; // Type comparer function
    类型映射_ mapper; // Mapper that fixes inferences
    类型映射_ nonFixingMapper; // Mapper that doesn't fix inferences
    类型映射_ returnMapper; // Type mapper for inferences from return types (if any)
    Klang类型_[] inferredTypeParameters; // Inferred type parameters for function result
    this() { }
    this(推理信息_[] inferences, 推理标志_ flags, 类型比较_ compareTypes, 类型映射_ mapper, 类型映射_ nonFixingMapper, Klang签名_ signature = ··null!(Klang签名_), 类型映射_ returnMapper = ··null!(类型映射_), Klang类型_[] inferredTypeParameters = ··null!(Klang类型_[])) {
        this.inferences = inferences;
        this.signature = signature;
        this.flags = flags;
        this.compareTypes = cast(类型比较_)(compareTypes);
        this.mapper = cast(类型映射_)(mapper);
        this.nonFixingMapper = cast(类型映射_)(nonFixingMapper);
        this.returnMapper = cast(类型映射_)(returnMapper);
        this.inferredTypeParameters = inferredTypeParameters;
    }
}
class 流类型_ : Klang类型_ {
    this() { }
    this(Klang类型_ 类型) {
        super((cast(整数_)(类型标志_.无_)));
        this.类型 = 类型;
    }
}
class 字面量值_ {
    字面量值种类_ 标志;
    ulong 正整数64_;
    double 小数_;
    dstring 文本_;
    this() { }
    this(字面量值种类_ _种类, float _值) {
        this.标志 = _种类;
        this.正整数64_ = .返回零值!(ulong)();
        this.小数_ = _值;
        this.文本_ = .返回零值!(dstring)();
    }
    this(字面量值种类_ _种类, double _值) {
        this.标志 = _种类;
        this.正整数64_ = .返回零值!(ulong)();
        this.小数_ = _值;
        this.文本_ = .返回零值!(dstring)();
    }
    this(字面量值种类_ _种类, int _值) {
        this.标志 = _种类;
        this.正整数64_ = _值;
        this.小数_ = .返回零值!(double)();
        this.文本_ = .返回零值!(dstring)();
    }
    this(字面量值种类_ _种类, long _值) {
        this.标志 = _种类;
        this.正整数64_ = _值;
        this.小数_ = .返回零值!(double)();
        this.文本_ = .返回零值!(dstring)();
    }
    this(字面量值种类_ _种类, ulong _值) {
        this.标志 = _种类;
        this.正整数64_ = _值;
        this.小数_ = .返回零值!(double)();
        this.文本_ = .返回零值!(dstring)();
    }
    this(字面量值种类_ _种类, dstring _值) {
        this.标志 = _种类;
        this.正整数64_ = .返回零值!(ulong)();
        this.小数_ = .返回零值!(double)();
        this.文本_ = _值;
    }
    double 获取小数(字面量值种类_ _种类) {
        assert(_种类 == this.标志, "值验证错误1."c);
        return this.小数_;
    }
    dstring 获取文本(字面量值种类_ _种类) {
        assert(_种类 == this.标志, "值验证错误2."c);
        return this.文本_;
    }
    int 获取整数(字面量值种类_ _种类) {
        assert(_种类 == this.标志, "值验证错误3."c);
        return (cast(int)(this.正整数64_));
    }
    long 获取整数64(字面量值种类_ _种类) {
        assert(_种类 == this.标志, "值验证错误4."c);
        return (cast(整数_)(this.正整数64_));
    }
    long 获取整数64() {
        return (cast(整数_)(this.正整数64_));
    }
    ulong 获取正整数64(字面量值种类_ _种类) {
        assert(_种类 == this.标志, "值验证错误5."c);
        return (cast(ulong)(this.正整数64_));
    }
}
class Klang类型_ : 类型_ {
    复合标志_ 复合标志;
    Klang类型_ 类型;
    Klang类型_[] 类型组;
    Klang类型_[] 类型实参;
    符号表_ 属性组;
    符号表_ 重载属性组;
    符号表_ 方法组;
    Klang签名_[] 构建组;
    Klang签名_[] 调用组;
    词典_!(运算符信息_) 运算符;
    Klang类型_ 解析的基类;
    Klang类型_[] 实现的接口;
    Klang类型_[] 扩展的接口;
    Klang签名_[] 虚表;
    索引信息_ 文本索引;
    索引信息_ 数字索引;
    Klang类型_ 原型类型;
    Klang类型_ 约束类型;
    Klang类型_ 常规类型;
    Klang类型_ origin;
    Klang类型_ 空类型;
    字面量值_ 值;
    Klang类型_ 新鲜类型;
    Klang类型_ 长度;
    long 容量;
    Klang类型_[] 类型形参;
    Klang类型_ 泛型目标;
    类型映射_ 映射;
    节点_ 节点;
    Klang类型_ literalType;
    方差_[] variances; // Variance of each type parameter
    词典_!(Klang类型_) instantiations; // Generic instantiation cache
    Klang符号_ 构建符号;
    Klang符号_ 释放符号;
    Klang符号_ aliasSymbol; // Alias associated with type
    Klang类型_[] aliasTypeArguments; // Alias type arguments (if any)
    bool aliasTypeArgumentsContainsMarker; // Alias type arguments (if any)
    Klang类型_ permissiveInstantiation; // Instantiation with type parameters mapped to wildcard type
    Klang类型_ restrictiveInstantiation; // 将类型参数映射到无约束形式的实例化
    Klang类型_ immediateBaseConstraint; // Immediate base constraint cache
    Klang类型_ resolvedBaseConstraint;
    Klang类型_ widened; // Cached widened form of the type
    dstring 实例化名称;
    Klang签名_ 当前需要实例化的签名;
    this() { }
    this(long 标志) {
        super(TK.Klang, 标志);
        this.类型 = ··null!(Klang类型_);
        this.类型组 = ··null!(Klang类型_[]);
        this.复合标志 = 复合标志_.无_;
        this.aliasSymbol = ··null!(Klang符号_);
        this.aliasTypeArguments = ··null!(Klang类型_[]);
        this.aliasTypeArgumentsContainsMarker = ··null!(bool);
        this.permissiveInstantiation = ··null!(Klang类型_);
        this.restrictiveInstantiation = ··null!(Klang类型_);
        this.immediateBaseConstraint = ··null!(Klang类型_);
        this.resolvedBaseConstraint = ··null!(Klang类型_);
        this.widened = ··null!(Klang类型_);
        this.类型实参 = ··null!(Klang类型_[]);
        this.属性组 = ··null!(符号表_);
        this.重载属性组 = ··null!(符号表_);
        this.方法组 = ··null!(符号表_);
        this.构建组 = ··null!(Klang签名_[]);
        this.调用组 = ··null!(Klang签名_[]);
        this.文本索引 = ··null!(索引信息_);
        this.数字索引 = ··null!(索引信息_);
        this.运算符 = ··null!(词典_!(运算符信息_));
        this.解析的基类 = ··null!(Klang类型_);
        this.实现的接口 = ··null!(Klang类型_[]);
        this.扩展的接口 = ··null!(Klang类型_[]);
        this.原型类型 = ··null!(Klang类型_);
        this.常规类型 = ··null!(Klang类型_);
        this.origin = ··null!(Klang类型_);
        this.空类型 = ··null!(Klang类型_);
        this.值 = ··null!(字面量值_);
        this.新鲜类型 = ··null!(Klang类型_);
        this.长度 = ··null!(Klang类型_);
        this.容量 = 0;
        this.虚表 = ··null!(Klang签名_[]);
        this.类型形参 = ··null!(Klang类型_[]);
        this.泛型目标 = ··null!(Klang类型_);
        this.映射 = ··null!(类型映射_);
        this.节点 = ··null!(节点_);
        this.literalType = ··null!(Klang类型_);
        this.variances = ··null!(方差_[]);
        this.instantiations = ··null!(词典_!(Klang类型_));
        this.约束类型 = ··null!(Klang类型_);
        this.构建符号 = ··null!(Klang符号_);
        this.释放符号 = ··null!(Klang符号_);
        this.实例化名称 = ""d;
        this.当前需要实例化的签名 = ··null!(Klang签名_);
    }
    this(long 标志, dstring 名称) {
        super(TK.Klang, 标志, 名称);
        this.类型 = ··null!(Klang类型_);
        this.类型组 = ··null!(Klang类型_[]);
        this.复合标志 = 复合标志_.无_;
        this.aliasSymbol = ··null!(Klang符号_);
        this.aliasTypeArguments = ··null!(Klang类型_[]);
        this.aliasTypeArgumentsContainsMarker = ··null!(bool);
        this.permissiveInstantiation = ··null!(Klang类型_);
        this.restrictiveInstantiation = ··null!(Klang类型_);
        this.immediateBaseConstraint = ··null!(Klang类型_);
        this.widened = ··null!(Klang类型_);
        this.resolvedBaseConstraint = ··null!(Klang类型_);
        this.类型实参 = ··null!(Klang类型_[]);
        this.属性组 = ··null!(符号表_);
        this.重载属性组 = ··null!(符号表_);
        this.构建组 = ··null!(Klang签名_[]);
        this.方法组 = ··null!(符号表_);
        this.调用组 = ··null!(Klang签名_[]);
        this.文本索引 = ··null!(索引信息_);
        this.数字索引 = ··null!(索引信息_);
        this.运算符 = ··null!(词典_!(运算符信息_));
        this.解析的基类 = ··null!(Klang类型_);
        this.实现的接口 = ··null!(Klang类型_[]);
        this.扩展的接口 = ··null!(Klang类型_[]);
        this.原型类型 = ··null!(Klang类型_);
        this.常规类型 = ··null!(Klang类型_);
        this.origin = ··null!(Klang类型_);
        this.空类型 = ··null!(Klang类型_);
        this.值 = ··null!(字面量值_);
        this.新鲜类型 = ··null!(Klang类型_);
        this.长度 = ··null!(Klang类型_);
        this.容量 = 0;
        this.虚表 = ··null!(Klang签名_[]);
        this.类型形参 = ··null!(Klang类型_[]);
        this.泛型目标 = ··null!(Klang类型_);
        this.映射 = ··null!(类型映射_);
        this.节点 = ··null!(节点_);
        this.literalType = ··null!(Klang类型_);
        this.variances = ··null!(方差_[]);
        this.instantiations = ··null!(词典_!(Klang类型_));
        this.约束类型 = ··null!(Klang类型_);
        this.构建符号 = ··null!(Klang符号_);
        this.释放符号 = ··null!(Klang符号_);
        this.实例化名称 = ""d;
        this.当前需要实例化的签名 = ··null!(Klang签名_);
    }
}
class 索引信息_ {
    Klang类型_ 类型;
    索引签名_ 索引签名;
    this() { }
    this(Klang类型_ _类型, 索引签名_ _索引签名) {
        this.类型 = _类型;
        this.索引签名 = _索引签名;
    }
}
class 运算符信息_ {
    KSK op;
    Klang类型_ opType;
    Klang类型_ type;
    this() { }
    this(KSK _op, Klang类型_ _opType = ··null!(Klang类型_), Klang类型_ _type = ··null!(Klang类型_)) {
        this.op = _op;
        this.opType = _opType;
        this.type = _type;
    }
}
class Klang签名_ : 签名_ {
    Klang节点_ 签名声明;
    Klang类型_[] 类型实参;
    Klang类型_[] 通用变长实参;
    Klang类型_[] 类型形参组;
    Klang符号_[] 形参声明组;
    long 最小实参数量;
    Klang类型_ 返回类型;
    Klang签名_ 泛型目标;
    类型映射_ 类型映射;
    Klang签名_ baseSignatureCache;
    Klang签名_ erasedSignatureCache;
    词典_!(Klang签名_) instantiations;
    词典_!(Klang签名_) 实例化剩余参数签名;
    Klang类型_ isolatedSignatureType;
    Klang签名_ canonicalSignatureCache;
    long 虚表索引;
    词典_!(long) 接口虚表索引;
    dstring 碎裂名称;
    this() { }
    this(签名标志_ 标志) {
        super(TK.Klang, (cast(整数_)(标志)));
        this.最小实参数量 = ··null!(long);
        this.签名声明 = ··null!(Klang节点_);
        this.类型实参 = ··null!(Klang类型_[]);
        this.通用变长实参 = ··null!(Klang类型_[]);
        this.类型形参组 = ··null!(Klang类型_[]);
        this.形参声明组 = ··null!(Klang符号_[]);
        this.返回类型 = ··null!(Klang类型_);
        this.泛型目标 = ··null!(Klang签名_);
        this.类型映射 = ··null!(类型映射_);
        this.baseSignatureCache = ··null!(Klang签名_);
        this.erasedSignatureCache = ··null!(Klang签名_);
        this.instantiations = ··null!(词典_!(Klang签名_));
        this.实例化剩余参数签名 = ··null!(词典_!(Klang签名_));
        this.isolatedSignatureType = ··null!(Klang类型_);
        this.canonicalSignatureCache = ··null!(Klang签名_);
        this.虚表索引 = -1;
        this.接口虚表索引 = ··null!(词典_!(long));
        this.碎裂名称 = ""d;
    }
}
class Klang符号_ : 符号_ {
    符号检查标志_ 检查标志;
    long 合并Id;
    符号标志_ isReferenced;
    符号_ 别名目标;
    Klang类型_ 声明类型;
    Klang类型_ 类型;
    Klang类型_[] 类型形参;
    Klang类型_ 虚拟类型;
    词典_!(Klang类型_) instantiations; // Generic instantiation cache
    枚举种类_ 枚举种类;
    Klang类型_ 枚举基类型;
    符号表_ 解析的成员;
    Klang符号_ 泛型目标;
    类型映射_ 类型映射;
    外部修饰符声明_ 外部修饰符;
    bool isAssigned;
    词典_!(符号_[]) accessibleChainCache;
    Klang符号_ 覆盖的基类方法;
    Klang签名_[] 解析的签名组;
    bool 成员类型检查;
    bool 接口循环引用;
    long 虚表索引;
    dstring[] 碎裂名称;
    词典_!(long) 接口虚表索引;
    符号_ 重载的基类属性;
    this() { }
    this(long 标志, dstring 名称) {
        super(TK.Klang, 标志, 名称);
        this.合并Id = 0;
        this.isReferenced = 符号标志_.无_;
        this.检查标志 = 符号检查标志_.无_;
        this.别名目标 = ··null!(符号_);
        this.声明类型 = ··null!(Klang类型_);
        this.类型形参 = ··null!(Klang类型_[]);
        this.instantiations = ··null!(词典_!(Klang类型_));
        this.枚举种类 = 枚举种类_.无_;
        this.枚举基类型 = ··null!(Klang类型_);
        this.解析的成员 = ··null!(符号表_);
        this.类型 = ··null!(Klang类型_);
        this.泛型目标 = ··null!(Klang符号_);
        this.类型映射 = ··null!(类型映射_);
        this.外部修饰符 = ··null!(外部修饰符声明_);
        this.isAssigned = false;
        this.accessibleChainCache = ··null!(词典_!(符号_[]));
        this.解析的签名组 = ··null!(Klang签名_[]);
        this.覆盖的基类方法 = ··null!(Klang符号_);
        this.虚拟类型 = ··null!(Klang类型_);
        this.成员类型检查 = false;
        this.接口循环引用 = false;
        this.虚表索引 = -1;
        this.碎裂名称 = ··null!(dstring[]);
        this.接口虚表索引 = ··null!(词典_!(long));
        this.重载的基类属性 = ··null!(符号_);
    }
    override dstring 打印() {
        if ((this.父符号 !is ··null!(符号_)) && (this.父符号.标志 & 符号标志_.类型形参_) == 0) {
            return this.父符号.打印() ~ "."d ~ this.名称;
        }
        else {
            return this.名称;
        }
    }
}
class 合成的类型组_ {
    bool truncating = false;
    long addedLength = 0;
    节点_ 类型节点;
    this() { }
    this(节点_ _类型节点) {
        this.类型节点 = _类型节点;
    }
}
class 属性赋值语句组检查结果_ {
    Klang节点_[] 赋值组;
    long 在循环内有赋值;
    this() { }
    this(Klang节点_[] _赋值组, long _在循环内有赋值) {
        this.赋值组 = _赋值组;
        this.在循环内有赋值 = _在循环内有赋值;
    }
}
class 节点扩展_ {
    节点检查标志_ 标志;
    节点_ 节点;
    Klang类型_ 计算的枚举成员值;
    Klang类型_ 解析类型;
    Klang符号_ 解析符号;
    Klang签名_ 解析的签名;
    bool 运算符签名已经检查;
    bool skipDirectInference;
    词典_!(Klang节点_) deferredNodes;
    二元结构_!(Klang签名_) effectsSignature;
    二元结构_!(dstring) isExhaustive;
    Klang类型_[] switchTypes;
    bool hasReportedStatementInAmbientContext;
    Klang类型_ contextFreeType;
    Klang类型_[] 类型形参;
    bool 已经收集外部形参;
    属性赋值语句组检查结果_ 属性赋值语句组;
    Klang节点_[] 重解析的实参组;
    Klang节点_ 实参展开前的节点;
    词典_!(合成的类型组_) serializedTypes;
    bool 静态语句已经计算;
    Ternary 是静态语句;
    类型映射_ 断言映射;
    类型映射_ 替换映射;
    复合标志_ 断言标志;
    Klang类型_[] 断言形参组;
    三元结果_ 计算的版本表达式;
    签名_ 实例化的签名;
    this() { }
    this(节点_ _节点, 节点检查标志_ _标志) {
        this.节点 = _节点;
        this.标志 = _标志;
        this.计算的枚举成员值 = ··null!(Klang类型_);
        this.解析类型 = ··null!(Klang类型_);
        this.解析符号 = ··null!(Klang符号_);
        this.解析的签名 = ··null!(Klang签名_);
        this.运算符签名已经检查 = false;
        this.skipDirectInference = false;
        this.deferredNodes = ··null!(词典_!(Klang节点_));
        this.effectsSignature = .二元结构_!(Klang签名_)(false);
        this.isExhaustive = .二元结构_!(dstring)(false);
        this.switchTypes = ··null!(Klang类型_[]);
        this.hasReportedStatementInAmbientContext = false;
        this.contextFreeType = ··null!(Klang类型_);
        this.类型形参 = ··null!(Klang类型_[]);
        this.已经收集外部形参 = false;
        this.属性赋值语句组 = ··null!(属性赋值语句组检查结果_);
        this.重解析的实参组 = ··null!(Klang节点_[]);
        this.实参展开前的节点 = ··null!(Klang节点_);
        this.静态语句已经计算 = false;
        this.是静态语句 = Ternary.False;
        this.断言映射 = ··null!(类型映射_);
        this.替换映射 = ··null!(类型映射_);
        this.断言标志 = 复合标志_.无_;
        this.断言形参组 = ··null!(Klang类型_[]);
        this.计算的版本表达式 = 三元结果_.初始_;
        this.实例化的签名 = ··null!(签名_);
    }
}
class NodeBuilderContext {
    节点_ enclosingDeclaration;
    NodeBuilderFlags flags;
    // State
    bool encounteredError;
    bool reportedDiagnostic;
    词典_!(dstring) visitedTypes;
    词典_!(long) symbolDepth;
    Klang类型_[] inferTypeParameters;
    long approximateLength;
    bool truncating;
    词典_!(long) typeParameterSymbolList;
    词典_!(标识符_) typeParameterNames;
    词典_!(dstring) typeParameterNamesByText;
    词典_!(long) typeParameterNamesByTextNextNameCount;
    词典_!(dstring) usedSymbolNames;
    词典_!(dstring) remappedSymbolNames;
    this() { }
    this(NodeBuilderFlags _flags, 节点_ _enclosingDeclaration = ··null!(节点_)) {
        this.flags = _flags;
        this.enclosingDeclaration = _enclosingDeclaration;
        this.encounteredError = false;
        this.reportedDiagnostic = false;
        this.approximateLength = 0;
        this.visitedTypes = .返回零值!(词典_!(dstring))();
        this.symbolDepth = .返回零值!(词典_!(long))();
        this.inferTypeParameters = .返回零值!(Klang类型_[])();
        this.truncating = false;
        this.typeParameterSymbolList = .返回零值!(词典_!(long))();
        this.typeParameterNames = .返回零值!(词典_!(标识符_))();
        this.typeParameterNamesByText = .返回零值!(词典_!(dstring))();
        this.typeParameterNamesByTextNextNameCount = .返回零值!(词典_!(long))();
        this.usedSymbolNames = .返回零值!(词典_!(dstring))();
        this.remappedSymbolNames = .返回零值!(词典_!(dstring))();
    }
}
struct 作者_ {
    dstring 姓名;
    dstring 公司 = ··null!(dstring);
    dstring 邮箱 = ··null!(dstring);
    dstring 博客 = ··null!(dstring);
    this(dstring 姓名, dstring 公司 = ··null!(dstring), dstring 邮箱 = ··null!(dstring), dstring 博客 = ··null!(dstring)) {
        this.姓名 = 姓名;
        this.公司 = 公司;
        this.邮箱 = 邮箱;
        this.博客 = 博客;
    }
}
struct 编译的命令行_ {
    编译选项_ options;
    诊断_[] errors;
    dstring[] fileNames;
    dstring 全局模块位置;
    bool 保存时编译 = ··null!(bool);
    通配符目录标志_[dstring] 通配符目录 = ··null!(通配符目录标志_[dstring]);
    /* @internal */ 配置文件规范_ 配置文件规范 = ··null!(配置文件规范_);
    this(编译选项_ options, dstring[] fileNames, 诊断_[] errors, dstring 全局模块位置) {
        this.options = options;
        this.fileNames = fileNames;
        this.errors = errors;
        this.全局模块位置 = 全局模块位置;
    }
}
struct 配置文件规范_ {
    通配符目录标志_[dstring] 通配符目录;
    this(通配符目录标志_[dstring] 通配符目录) {
        this.通配符目录 = 通配符目录;
    }
}
struct 二元结构_(T) {
    bool 无_;
    T 值;
    this(T 值) {
        this.无_ = false;
        this.值 = 值;
    }
    this(bool 无, T 值) {
        this.无_ = 无;
        this.值 = 值;
    }
    this(bool 无) {
        this.无_ = 无;
        this.值 = .返回零值!(T)();
    }
}
Klang类型_ 复制类型(Klang类型_ sou) {
    Klang类型_ tar = new Klang类型_((cast(整数_)(类型标志_.无_)));
    tar.系统标志 = sou.系统标志;
    tar.目标 = sou.目标;
    tar.标志 = sou.标志;
    tar.id = sou.id;
    tar.扩展 = sou.扩展;
    tar.名称 = sou.名称;
    tar.符号 = sou.符号;
    tar.大小 = sou.大小;
    tar.成员已解析 = sou.成员已解析;
    tar.类型 = sou.类型;
    tar.类型组 = sou.类型组;
    tar.复合标志 = sou.复合标志;
    tar.aliasSymbol = sou.aliasSymbol;
    tar.aliasTypeArguments = sou.aliasTypeArguments;
    tar.aliasTypeArgumentsContainsMarker = sou.aliasTypeArgumentsContainsMarker;
    tar.permissiveInstantiation = sou.permissiveInstantiation;
    tar.restrictiveInstantiation = sou.restrictiveInstantiation;
    tar.immediateBaseConstraint = sou.immediateBaseConstraint;
    tar.widened = sou.widened;
    tar.resolvedBaseConstraint = sou.resolvedBaseConstraint;
    tar.类型实参 = sou.类型实参;
    tar.属性组 = sou.属性组;
    tar.重载属性组 = sou.重载属性组;
    tar.构建组 = sou.构建组;
    tar.方法组 = sou.方法组;
    tar.调用组 = sou.调用组;
    tar.文本索引 = sou.文本索引;
    tar.数字索引 = sou.数字索引;
    tar.运算符 = sou.运算符;
    tar.解析的基类 = sou.解析的基类;
    tar.实现的接口 = sou.实现的接口;
    tar.扩展的接口 = sou.扩展的接口;
    tar.原型类型 = sou.原型类型;
    tar.常规类型 = sou.常规类型;
    tar.origin = sou.origin;
    tar.空类型 = sou.空类型;
    tar.值 = sou.值;
    tar.新鲜类型 = sou.新鲜类型;
    tar.长度 = sou.长度;
    tar.容量 = sou.容量;
    tar.类型形参 = sou.类型形参;
    tar.泛型目标 = sou.泛型目标;
    tar.映射 = sou.映射;
    tar.节点 = sou.节点;
    tar.literalType = sou.literalType;
    tar.variances = sou.variances;
    tar.instantiations = sou.instantiations;
    tar.约束类型 = sou.约束类型;
    tar.构建符号 = sou.构建符号;
    tar.释放符号 = sou.释放符号;
    return tar;
}
Klang类型_ 新建联合类型(Klang类型_[] _类型组) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.联合_)));
    类型.类型组 = _类型组;
    类型.名称 = "联合类型"d;
    return 类型;
}
Klang类型_ 新建可选类型(Klang类型_ _类型, Klang类型_ _空类型 = ··null!(Klang类型_)) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.可选类型_)));
    类型.复合标志 |= 复合标志_.可选类型_;
    类型.名称 = "可选类型"d;
    类型.类型 = _类型;
    if (_空类型 !is ··null!(Klang类型_)) {
        类型.空类型 = _空类型;
    }
    return 类型;
}
Klang类型_ 新建字面量类类型(类型标志_ 标志) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(标志)));
    类型.名称 = "字面量类类型"d;
    类型.复合标志 |= 复合标志_.内置类型字面量_;
    return 类型;
}
Klang类型_ 新建数组类型(Klang类型_ _类型, Klang类型_ _长度, long _容量 = 0) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.复合_)));
    类型.名称 = "数组类型"d;
    类型.复合标志 = 复合标志_.数组_;
    类型.类型 = _类型;
    类型.长度 = _长度;
    类型.容量 = _容量;
    return 类型;
}
Klang类型_ 新建动态数组(Klang类型_ _类型, long _容量 = 0) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.复合_)));
    类型.名称 = "动态数组"d;
    类型.复合标志 = 复合标志_.动态_;
    类型.类型 = _类型;
    类型.容量 = _容量;
    return 类型;
}
Klang类型_ 新建变长参数类型(Klang类型_ _类型) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.复合_)));
    类型.名称 = "变长参数类型"d;
    类型.复合标志 = 复合标志_.变长_;
    类型.类型 = _类型;
    return 类型;
}
Klang类型_ 新建类型列表类型(Klang类型_ _类型) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.复合_)));
    类型.名称 = "类型列表类型"d;
    类型.复合标志 = 复合标志_.列表_;
    类型.类型 = _类型;
    return 类型;
}
Klang类型_ 新建指针类型(Klang类型_ _类型) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.复合_)));
    类型.名称 = "指针类型"d;
    类型.复合标志 = 复合标志_.指针_;
    类型.类型 = _类型;
    return 类型;
}
Klang类型_ 新建词典类型(Klang类型_[] _类型组) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.复合_)));
    类型.名称 = "词典类型"d;
    类型.复合标志 = 复合标志_.词典_;
    类型.类型组 = _类型组;
    return 类型;
}
Klang类型_ 新建元组类型(Klang类型_[] _类型组) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.复合_)));
    类型.名称 = "元组类型"d;
    类型.复合标志 = 复合标志_.元组_;
    类型.类型组 = _类型组;
    return 类型;
}
Klang类型_ 新建只读类型(Klang类型_ _类型) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.限定类型_)));
    类型.名称 = "只读类型"d;
    类型.复合标志 = 复合标志_.只读_;
    类型.类型 = _类型;
    return 类型;
}
Klang类型_ 新建恒定类型(Klang类型_ _类型) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.限定类型_)));
    类型.名称 = "恒定类型"d;
    类型.复合标志 = 复合标志_.恒定_;
    类型.类型 = _类型;
    return 类型;
}
Klang类型_ 新建共享类型(Klang类型_ _类型) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.限定类型_)));
    类型.名称 = "共享类型"d;
    类型.复合标志 = 复合标志_.共享_;
    类型.类型 = _类型;
    return 类型;
}
Klang类型_ 新建对象接口(Klang类型_ _类型) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.限定类型_)));
    类型.名称 = "对象接口"d;
    类型.复合标志 = 复合标志_.对象接口_;
    类型.类型 = _类型;
    return 类型;
}
Klang类型_ 新建结构接口(Klang类型_ _类型) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.限定类型_)));
    类型.名称 = "结构接口"d;
    类型.复合标志 = 复合标志_.结构接口_;
    类型.类型 = _类型;
    return 类型;
}
T 返回零值(T)() {
    return ··null!(T);
}
Klang类型_ 新建实例化类型(复合标志_ _标志) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.对象_)));
    类型.名称 = "实例化类型"d;
    类型.复合标志 = _标志;
    return 类型;
}
Klang类型_ 新建类型形参(Klang符号_ 符号) {
    Klang类型_ 类型 = .新建实例化类型(复合标志_.类型形参_);
    类型.名称 = "类型形参"d;
    类型.标志 &= ~(cast(整数_)(类型标志_.对象_));
    类型.标志 |= (cast(整数_)(类型标志_.类型形参_));
    类型.符号 = 符号;
    return 类型;
}
Klang类型_ 新建类类型(Klang符号_ 符号) {
    Klang类型_ 类型 = .新建实例化类型(复合标志_.类_);
    类型.名称 = "类类型"d;
    类型.符号 = 符号;
    return 类型;
}
Klang类型_ 新建结构类型(Klang符号_ 符号) {
    Klang类型_ 类型 = .新建实例化类型(复合标志_.结构_);
    类型.名称 = "结构类型"d;
    类型.符号 = 符号;
    return 类型;
}
Klang类型_ 新建接口类型(Klang符号_ 符号) {
    Klang类型_ 类型 = .新建实例化类型(复合标志_.接口_);
    类型.名称 = "接口类型"d;
    类型.符号 = 符号;
    return 类型;
}
Klang类型_ 新建事件类型(Klang符号_ 符号) {
    Klang类型_ 类型 = .新建实例化类型(复合标志_.接口_);
    类型.名称 = "事件类型"d;
    类型.符号 = 符号;
    return 类型;
}
Klang类型_ 新建类型类型(Klang符号_ 符号) {
    Klang类型_ 类型 = .新建实例化类型(复合标志_.类型_);
    类型.名称 = "类型类型"d;
    类型.符号 = 符号;
    return 类型;
}
Klang类型_ 新建匿名类型(Klang符号_ 符号 = ··null!(Klang符号_)) {
    Klang类型_ 类型 = .新建实例化类型(复合标志_.匿名_);
    类型.名称 = "匿名类型"d;
    if (符号 !is ··null!(Klang符号_)) {
        类型.符号 = 符号;
    }
    return 类型;
}
Klang类型_ 新建程序类型(Klang符号_ 符号) {
    Klang类型_ 类型 = .新建实例化类型(复合标志_.程序_);
    类型.名称 = "程序类型"d;
    类型.符号 = 符号;
    return 类型;
}
Klang类型_ 新建排除集类型(Klang类型_ _类型) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.排除集类型_)));
    类型.类型 = _类型;
    类型.名称 = "排除集类型"d;
    类型.类型组 = 创建数组!(Klang类型_)();
    return 类型;
}
Klang类型_ 新建虚拟外部类型(dstring 名称) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.对象_)));
    类型.复合标志 |= 复合标志_.虚拟外部类型_;
    类型.符号 = new Klang符号_((cast(整数_)(符号标志_.对象_ | 符号标志_.虚拟符号_)), 名称);
    类型.名称 = 名称;
    return 类型;
}
Klang类型_ 新建虚拟外部函数(dstring 名称) {
    Klang类型_ 类型 = new Klang类型_((cast(整数_)(类型标志_.对象_)));
    类型.复合标志 |= 复合标志_.匿名_ | 复合标志_.虚拟外部函数_;
    类型.符号 = new Klang符号_((cast(整数_)(符号标志_.函数_ | 符号标志_.虚拟符号_)), 名称);
    类型.名称 = 名称;
    return 类型;
}
Klang签名_ 拷贝签名(Klang签名_ sou) {
    Klang签名_ tar = new Klang签名_(签名标志_.无_);
    tar.系统标志 = sou.系统标志;
    tar.目标 = sou.目标;
    tar.标志 = sou.标志;
    tar.id = 0;
    tar.扩展 = sou.扩展;
    tar.最小实参数量 = sou.最小实参数量;
    tar.签名声明 = sou.签名声明;
    tar.类型实参 = sou.类型实参;
    tar.通用变长实参 = sou.通用变长实参;
    tar.类型形参组 = sou.类型形参组;
    tar.形参声明组 = sou.形参声明组;
    if ((sou.泛型目标 !is ··null!(Klang签名_)) && sou != sou.泛型目标) {
        tar.泛型目标 = .拷贝签名(sou.泛型目标);
    }
    tar.类型映射 = sou.类型映射;
    tar.baseSignatureCache = sou.baseSignatureCache;
    tar.erasedSignatureCache = sou.erasedSignatureCache;
    tar.instantiations = sou.instantiations;
    tar.实例化剩余参数签名 = sou.实例化剩余参数签名;
    tar.isolatedSignatureType = sou.isolatedSignatureType;
    tar.canonicalSignatureCache = sou.canonicalSignatureCache;
    tar.虚表索引 = sou.虚表索引;
    tar.接口虚表索引 = sou.接口虚表索引;
    tar.碎裂名称 = sou.碎裂名称;
    return tar;
}
